#include "infrastructure_registrar.h"
#include "infrastructure/factories/logger_factory.h"
#include "infrastructure/configuration/composite_configuration_provider.h"
#include "infrastructure/configuration/json_file_provider.h"
#include "infrastructure/configuration/environment_variable_provider.h"
#include "infrastructure/map/map_service.h"
#include "infrastructure/services/common_service.h"
#include "kernel/interfaces/ILogger.h"
#include <QCoreApplication>
#include <QFile>

// TODO: 等待基础设施层实现后取消注释
// #include "infrastructure/logging/ConsoleLogger.h"
// #include "infrastructure/communication/MqttCommunicationService.h"
// #include "infrastructure/persistence/SqlAgvRepository.h"
// #include "infrastructure/persistence/SqlTaskRepository.h"

// 接口
// #include "kernel/interfaces/ILogger.h"
// #include "kernel/interfaces/ICommunicationService.h"
// #include "kernel/interfaces/IAgvRepository.h"
// #include "kernel/interfaces/ITaskRepository.h"

using namespace infrastructure::services;
using namespace infrastructure::factories;
using namespace bootstrap::factories;

namespace bootstrap {
namespace registrars {

InfrastructureRegistrar::InfrastructureRegistrar(std::shared_ptr<ServiceContainer> container)
    : BaseRegistrar(container, "InfrastructureRegistrar")
{
}

void InfrastructureRegistrar::doRegisterServices()
{
    logInfo("开始注册基础设施层服务");

    // 注册各类基础设施服务
    registerLogging();
    registerCommunication();
    registerPersistence();
    registerOtherServices();

    logInfo("基础设施层服务注册完成");
}

void InfrastructureRegistrar::doInitializeServices()
{
    logInfo("开始初始化基础设施层服务");

    // 使用基类的安全初始化方法
    safeInitializeService<LoggerFactory>("日志工厂", true);

    // 初始化配置服务
    safeInitializeService<kernel::IConfiguration>("配置服务", true);

    // 初始化地图服务
    safeInitializeService<infrastructure::MapService>("地图服务", true);

    // 初始化通用服务（在所有基础设施层服务的最后）
    safeInitializeService<CommonService>("通用服务", true);

    logInfo("基础设施层服务初始化完成");
}

void InfrastructureRegistrar::registerLogging()
{
    logInfo("注册日志工厂");

    // 注册LoggerFactory作为单例
    auto factory = [](ServiceContainer& container) {
        // LoggerFactory不依赖其他服务，可以直接创建
        return std::make_shared<LoggerFactory>();
    };

    auto builder = registerService<LoggerFactory, LoggerFactory>()
        .withDescription("日志工厂 - 支持多日志器管理")
        .useCustomFactory(factory);

    addRegistration(std::move(builder));

    logInfo("日志工厂注册完成");
}

void InfrastructureRegistrar::registerCommunication()
{
    logInfo("注册通信服务");

    // TODO: 注册通信服务实现
    // addRegistration(
    //     registerService<ICommunicationService, MqttCommunicationService>()
    //         .withDescription("MQTT通信服务")
    //         .asSingleton()
    //         .useCustomFactory([](ServiceContainer& container) {
    //             auto logger = container.resolve<ILogger>();
    //             return std::make_shared<MqttCommunicationService>(logger);
    //         })
    // );

    logInfo("通信服务注册完成（占位符）");
}

void InfrastructureRegistrar::registerPersistence()
{
    logInfo("注册数据持久化服务");

    // TODO: 注册仓储实现
    // addRegistration(
    //     registerService<IAgvRepository, SqlAgvRepository>()
    //         .withDescription("AGV数据仓储")
    //         .asSingleton()
    //         .useCustomFactory([](ServiceContainer& container) {
    //             auto logger = container.resolve<ILogger>();
    //             return std::make_shared<SqlAgvRepository>(logger);
    //         })
    // );

    // addRegistration(
    //     registerService<ITaskRepository, SqlTaskRepository>()
    //         .withDescription("任务数据仓储")
    //         .asSingleton()
    //         .useCustomFactory([](ServiceContainer& container) {
    //             auto logger = container.resolve<ILogger>();
    //             return std::make_shared<SqlTaskRepository>(logger);
    //         })
    // );

    logInfo("数据持久化服务注册完成（占位符）");
}

void InfrastructureRegistrar::registerOtherServices()
{
    logInfo("注册其他基础设施服务");

    // 注册配置服务
    registerConfigurationService();

    // 注册地图服务
    registerMapService();

    // 注册通用服务（在所有基础设施层服务的最后）
    registerCommonService();

    logInfo("其他基础设施服务注册完成");
}

void InfrastructureRegistrar::registerConfigurationService()
{
    logInfo("注册配置服务");

    // 复合配置提供者 - 注册接口到实现
    addRegistration(
        std::move(registerService<kernel::IConfiguration, infrastructure::CompositeConfigurationProvider>()
            .withDescription("复合配置提供者")
            .withAutoInitialize(true)
            .useCustomFactory([](ServiceContainer& container) {
                auto logger = container.resolve<LoggerFactory>();
                if (!logger) {
                    throw std::runtime_error("无法解析日志记录器服务");
                }

                auto defaultLogger = logger->getDefaultLogger();
                if (!defaultLogger) {
                    throw std::runtime_error("无法获取默认日志器");
                }

                try {
                    // 创建复合配置提供者
                    auto configProvider = std::make_shared<infrastructure::CompositeConfigurationProvider>();

                    // 添加默认的配置源
                    // 添加JSON文件配置提供者（总是添加，不管文件是否存在）
                    QString configPath = QCoreApplication::applicationDirPath() + "/config/app_config.json";
                    auto jsonProvider = std::make_shared<infrastructure::JsonFileProvider>(configPath, 100);
                    configProvider->addProvider(jsonProvider);

                    if (QFile::exists(configPath)) {
                        defaultLogger->info(QString("已添加JSON配置文件提供者: %1 (文件存在)").arg(configPath));
                    } else {
                        defaultLogger->info(QString("已添加JSON配置文件提供者: %1 (文件不存在，将在首次保存时创建)").arg(configPath));
                    }
                    return configProvider;
                }
                catch (const std::exception& e) {
                    defaultLogger->warning(QString("配置提供者初始化警告: %1").arg(e.what()));
                    // 返回一个基本的配置提供者以确保系统继续运行
                    return std::make_shared<infrastructure::CompositeConfigurationProvider>();
                }
            })
        )
    );

    logInfo("配置服务注册完成");
}

void InfrastructureRegistrar::registerMapService()
{
    logInfo("注册地图服务");

    // 地图服务 - 注册单例
    auto mapServiceFactory = [](ServiceContainer& container) {
        // 使用LoggerFactory直接创建日志器，避免依赖CommonService
        auto loggerFactory = container.resolve<LoggerFactory>();
        if (!loggerFactory) {
            throw std::runtime_error("无法解析LoggerFactory服务");
        }

        auto logger = loggerFactory->getLogger("MapService");
        if (!logger) {
            throw std::runtime_error("无法创建MapService日志器");
        }

        return std::make_shared<infrastructure::MapService>(logger.get());
    };

    auto builder = registerService<infrastructure::MapService, infrastructure::MapService>()
        .withDescription("地图服务 - 地图文件解析和管理")
        .useCustomFactory(mapServiceFactory);

    addRegistration(std::move(builder));

    logInfo("地图服务注册完成");
}

void InfrastructureRegistrar::registerCommonService()
{
    logInfo("注册通用服务");

    // 通用服务 - 聚合日志工厂和配置
    auto factory = [](ServiceContainer& container) {
        auto loggerFactory = container.resolve<LoggerFactory>();
        auto configService = container.resolve<kernel::IConfiguration>();

        if (!loggerFactory) {
            throw std::runtime_error("通用服务依赖解析失败: LoggerFactory不可用");
        }

        if (!configService) {
            throw std::runtime_error("通用服务依赖解析失败: IConfiguration不可用");
        }

        return std::make_shared<CommonService>(loggerFactory, configService);
    };

    auto builder = registerService<CommonService, CommonService>()
        .withDescription("通用服务 - 聚合日志工厂和配置")
        .useCustomFactory(factory);

    addRegistration(std::move(builder));

    logInfo("通用服务注册完成");
}

} // namespace registrars
} // namespace bootstrap